/**
 * @author: lp
 * @create: 2021-06-29 10:37
 * @description: Integer包装类有一个内部类IntegerCache，默认缓存了[-127,128]的值
 * 0.看IntegerCache源码,很好懂
 * 1.包装:Integer a=1;相当于 Integer a = Integer.valueOf(1);
 * 2.拆装:Integer integer = 1;
 *   //自动装箱，相当于Integer integer = Integer.valueOf(1);
 *   int i = integer;
 *   //自动拆箱,相当于int i = integer.intValue();
 * 3.equals方法:先比较类型，在比较值
 * 4.对于大于128的值的比较
 * 5.AtomicStampedReference<Integer> reference = new AtomicStampedReference<Integer>(2000,1);修改不了值的坑
 *   AtomicStampedReference<Integer>泛型是对象，Integer是包装类,AtomicStampedReference.compareAndSet比较新值和旧值
 *   用的是expectedReference == current.reference，比较的是对象地址；参数compareAndSet(2000,20003...),2000会新创建一个
 *   Integer对象，并不是AtomicStampedReference的Integer对象
 */
public class IntegerTest {
    public static void main(String[] args) {
        //自动包装，相当于：Integer a = Integer.valueOf(1);对于在[-127,128]之间的值，是从IntegerCache.cache缓存中取的
        //Integer.valueOf(1),会先判断值是否在缓存中存在，存在直接返回缓存，不存在，new
        Integer a=1;
        //自动包装，相当于：Integer b = Integer.valueOf(1);对于在[-127,128]之间的值，是从IntegerCache.cache缓存中取的
        Integer b=1;
        System.out.println("b变量的class类型"+b.getClass());
        //new操作是一个新对象
        Integer c=new Integer(1);
        System.out.println("c变量的class类型"+c.getClass());
        //值大于128，会new Integer
        Integer d=1000;
        //值大于128，会new Integer
        Integer e=1000;

        //都是缓存对象，都是IntegerCache.cache，比较的是对象地址，是同一个:true
        System.out.println("a==b:"+ (a==b));

        //b是缓存对象，c是new的对象，地址比较不一致:false
        System.out.println("b==c:"+(b==c));

        //d和e都是new的对象，地址不一致:false
        System.out.println("d==e:"+(d==e));


        //eques比较的是类型和值:true
        //自己本身
        System.out.println("a.equals(b):"+a.equals(b));

        //a是缓存对象，类型是Integer,c是new的对象,类型也是Integer:true
        System.out.println("a.equals(c):"+a.equals(c));

    }
}
